/*
 * XML Type:  MessageSetList
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.MessageSetList
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML MessageSetList(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class MessageSetListImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.ofx.types.x2003.x04.MessageSetList
{
    
    public MessageSetListImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName SIGNONMSGSET$0 = 
        new javax.xml.namespace.QName("", "SIGNONMSGSET");
    private static final javax.xml.namespace.QName SIGNUPMSGSET$2 = 
        new javax.xml.namespace.QName("", "SIGNUPMSGSET");
    private static final javax.xml.namespace.QName BANKMSGSET$4 = 
        new javax.xml.namespace.QName("", "BANKMSGSET");
    private static final javax.xml.namespace.QName CREDITCARDMSGSET$6 = 
        new javax.xml.namespace.QName("", "CREDITCARDMSGSET");
    private static final javax.xml.namespace.QName INVSTMTMSGSET$8 = 
        new javax.xml.namespace.QName("", "INVSTMTMSGSET");
    private static final javax.xml.namespace.QName INTERXFERMSGSET$10 = 
        new javax.xml.namespace.QName("", "INTERXFERMSGSET");
    private static final javax.xml.namespace.QName WIREXFERMSGSET$12 = 
        new javax.xml.namespace.QName("", "WIREXFERMSGSET");
    private static final javax.xml.namespace.QName BILLPAYMSGSET$14 = 
        new javax.xml.namespace.QName("", "BILLPAYMSGSET");
    private static final javax.xml.namespace.QName EMAILMSGSET$16 = 
        new javax.xml.namespace.QName("", "EMAILMSGSET");
    private static final javax.xml.namespace.QName SECLISTMSGSET$18 = 
        new javax.xml.namespace.QName("", "SECLISTMSGSET");
    private static final javax.xml.namespace.QName PRESDIRMSGSET$20 = 
        new javax.xml.namespace.QName("", "PRESDIRMSGSET");
    private static final javax.xml.namespace.QName PRESDLVMSGSET$22 = 
        new javax.xml.namespace.QName("", "PRESDLVMSGSET");
    private static final javax.xml.namespace.QName TAX1099MSGSET$24 = 
        new javax.xml.namespace.QName("", "TAX1099MSGSET");
    private static final javax.xml.namespace.QName TAX1098MSGSET$26 = 
        new javax.xml.namespace.QName("", "TAX1098MSGSET");
    private static final javax.xml.namespace.QName TAXW2MSGSET$28 = 
        new javax.xml.namespace.QName("", "TAXW2MSGSET");
    private static final javax.xml.namespace.QName PROFMSGSET$30 = 
        new javax.xml.namespace.QName("", "PROFMSGSET");
    
    
    /**
     * Gets array of all "SIGNONMSGSET" elements
     */
    public net.ofx.types.x2003.x04.SignonMessageSet[] getSIGNONMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SIGNONMSGSET$0, targetList);
            net.ofx.types.x2003.x04.SignonMessageSet[] result = new net.ofx.types.x2003.x04.SignonMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SIGNONMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignonMessageSet getSIGNONMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignonMessageSet)get_store().find_element_user(SIGNONMSGSET$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SIGNONMSGSET" element
     */
    public int sizeOfSIGNONMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNONMSGSET$0);
        }
    }
    
    /**
     * Sets array of all "SIGNONMSGSET" element
     */
    public void setSIGNONMSGSETArray(net.ofx.types.x2003.x04.SignonMessageSet[] signonmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(signonmsgsetArray, SIGNONMSGSET$0);
        }
    }
    
    /**
     * Sets ith "SIGNONMSGSET" element
     */
    public void setSIGNONMSGSETArray(int i, net.ofx.types.x2003.x04.SignonMessageSet signonmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignonMessageSet)get_store().find_element_user(SIGNONMSGSET$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(signonmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SIGNONMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignonMessageSet insertNewSIGNONMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignonMessageSet)get_store().insert_element_user(SIGNONMSGSET$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SIGNONMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignonMessageSet addNewSIGNONMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignonMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignonMessageSet)get_store().add_element_user(SIGNONMSGSET$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "SIGNONMSGSET" element
     */
    public void removeSIGNONMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNONMSGSET$0, i);
        }
    }
    
    /**
     * Gets array of all "SIGNUPMSGSET" elements
     */
    public net.ofx.types.x2003.x04.SignupMessageSet[] getSIGNUPMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SIGNUPMSGSET$2, targetList);
            net.ofx.types.x2003.x04.SignupMessageSet[] result = new net.ofx.types.x2003.x04.SignupMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SIGNUPMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignupMessageSet getSIGNUPMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignupMessageSet)get_store().find_element_user(SIGNUPMSGSET$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SIGNUPMSGSET" element
     */
    public int sizeOfSIGNUPMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SIGNUPMSGSET$2);
        }
    }
    
    /**
     * Sets array of all "SIGNUPMSGSET" element
     */
    public void setSIGNUPMSGSETArray(net.ofx.types.x2003.x04.SignupMessageSet[] signupmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(signupmsgsetArray, SIGNUPMSGSET$2);
        }
    }
    
    /**
     * Sets ith "SIGNUPMSGSET" element
     */
    public void setSIGNUPMSGSETArray(int i, net.ofx.types.x2003.x04.SignupMessageSet signupmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignupMessageSet)get_store().find_element_user(SIGNUPMSGSET$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(signupmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SIGNUPMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignupMessageSet insertNewSIGNUPMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignupMessageSet)get_store().insert_element_user(SIGNUPMSGSET$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SIGNUPMSGSET" element
     */
    public net.ofx.types.x2003.x04.SignupMessageSet addNewSIGNUPMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SignupMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SignupMessageSet)get_store().add_element_user(SIGNUPMSGSET$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "SIGNUPMSGSET" element
     */
    public void removeSIGNUPMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SIGNUPMSGSET$2, i);
        }
    }
    
    /**
     * Gets array of all "BANKMSGSET" elements
     */
    public net.ofx.types.x2003.x04.BankMessageSet[] getBANKMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BANKMSGSET$4, targetList);
            net.ofx.types.x2003.x04.BankMessageSet[] result = new net.ofx.types.x2003.x04.BankMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BANKMSGSET" element
     */
    public net.ofx.types.x2003.x04.BankMessageSet getBANKMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BankMessageSet)get_store().find_element_user(BANKMSGSET$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BANKMSGSET" element
     */
    public int sizeOfBANKMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMSGSET$4);
        }
    }
    
    /**
     * Sets array of all "BANKMSGSET" element
     */
    public void setBANKMSGSETArray(net.ofx.types.x2003.x04.BankMessageSet[] bankmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bankmsgsetArray, BANKMSGSET$4);
        }
    }
    
    /**
     * Sets ith "BANKMSGSET" element
     */
    public void setBANKMSGSETArray(int i, net.ofx.types.x2003.x04.BankMessageSet bankmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BankMessageSet)get_store().find_element_user(BANKMSGSET$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bankmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BANKMSGSET" element
     */
    public net.ofx.types.x2003.x04.BankMessageSet insertNewBANKMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BankMessageSet)get_store().insert_element_user(BANKMSGSET$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BANKMSGSET" element
     */
    public net.ofx.types.x2003.x04.BankMessageSet addNewBANKMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BankMessageSet)get_store().add_element_user(BANKMSGSET$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "BANKMSGSET" element
     */
    public void removeBANKMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMSGSET$4, i);
        }
    }
    
    /**
     * Gets array of all "CREDITCARDMSGSET" elements
     */
    public net.ofx.types.x2003.x04.CreditcardMessageSet[] getCREDITCARDMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CREDITCARDMSGSET$6, targetList);
            net.ofx.types.x2003.x04.CreditcardMessageSet[] result = new net.ofx.types.x2003.x04.CreditcardMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "CREDITCARDMSGSET" element
     */
    public net.ofx.types.x2003.x04.CreditcardMessageSet getCREDITCARDMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardMessageSet target = null;
            target = (net.ofx.types.x2003.x04.CreditcardMessageSet)get_store().find_element_user(CREDITCARDMSGSET$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "CREDITCARDMSGSET" element
     */
    public int sizeOfCREDITCARDMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CREDITCARDMSGSET$6);
        }
    }
    
    /**
     * Sets array of all "CREDITCARDMSGSET" element
     */
    public void setCREDITCARDMSGSETArray(net.ofx.types.x2003.x04.CreditcardMessageSet[] creditcardmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(creditcardmsgsetArray, CREDITCARDMSGSET$6);
        }
    }
    
    /**
     * Sets ith "CREDITCARDMSGSET" element
     */
    public void setCREDITCARDMSGSETArray(int i, net.ofx.types.x2003.x04.CreditcardMessageSet creditcardmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardMessageSet target = null;
            target = (net.ofx.types.x2003.x04.CreditcardMessageSet)get_store().find_element_user(CREDITCARDMSGSET$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(creditcardmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "CREDITCARDMSGSET" element
     */
    public net.ofx.types.x2003.x04.CreditcardMessageSet insertNewCREDITCARDMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardMessageSet target = null;
            target = (net.ofx.types.x2003.x04.CreditcardMessageSet)get_store().insert_element_user(CREDITCARDMSGSET$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "CREDITCARDMSGSET" element
     */
    public net.ofx.types.x2003.x04.CreditcardMessageSet addNewCREDITCARDMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.CreditcardMessageSet target = null;
            target = (net.ofx.types.x2003.x04.CreditcardMessageSet)get_store().add_element_user(CREDITCARDMSGSET$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "CREDITCARDMSGSET" element
     */
    public void removeCREDITCARDMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CREDITCARDMSGSET$6, i);
        }
    }
    
    /**
     * Gets array of all "INVSTMTMSGSET" elements
     */
    public net.ofx.types.x2003.x04.InvestmentStatementMessageSet[] getINVSTMTMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INVSTMTMSGSET$8, targetList);
            net.ofx.types.x2003.x04.InvestmentStatementMessageSet[] result = new net.ofx.types.x2003.x04.InvestmentStatementMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INVSTMTMSGSET" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementMessageSet getINVSTMTMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementMessageSet)get_store().find_element_user(INVSTMTMSGSET$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INVSTMTMSGSET" element
     */
    public int sizeOfINVSTMTMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INVSTMTMSGSET$8);
        }
    }
    
    /**
     * Sets array of all "INVSTMTMSGSET" element
     */
    public void setINVSTMTMSGSETArray(net.ofx.types.x2003.x04.InvestmentStatementMessageSet[] invstmtmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(invstmtmsgsetArray, INVSTMTMSGSET$8);
        }
    }
    
    /**
     * Sets ith "INVSTMTMSGSET" element
     */
    public void setINVSTMTMSGSETArray(int i, net.ofx.types.x2003.x04.InvestmentStatementMessageSet invstmtmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementMessageSet)get_store().find_element_user(INVSTMTMSGSET$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(invstmtmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INVSTMTMSGSET" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementMessageSet insertNewINVSTMTMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementMessageSet)get_store().insert_element_user(INVSTMTMSGSET$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INVSTMTMSGSET" element
     */
    public net.ofx.types.x2003.x04.InvestmentStatementMessageSet addNewINVSTMTMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentStatementMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InvestmentStatementMessageSet)get_store().add_element_user(INVSTMTMSGSET$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "INVSTMTMSGSET" element
     */
    public void removeINVSTMTMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INVSTMTMSGSET$8, i);
        }
    }
    
    /**
     * Gets array of all "INTERXFERMSGSET" elements
     */
    public net.ofx.types.x2003.x04.InterTransferMessageSet[] getINTERXFERMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INTERXFERMSGSET$10, targetList);
            net.ofx.types.x2003.x04.InterTransferMessageSet[] result = new net.ofx.types.x2003.x04.InterTransferMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INTERXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.InterTransferMessageSet getINTERXFERMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InterTransferMessageSet)get_store().find_element_user(INTERXFERMSGSET$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INTERXFERMSGSET" element
     */
    public int sizeOfINTERXFERMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTERXFERMSGSET$10);
        }
    }
    
    /**
     * Sets array of all "INTERXFERMSGSET" element
     */
    public void setINTERXFERMSGSETArray(net.ofx.types.x2003.x04.InterTransferMessageSet[] interxfermsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(interxfermsgsetArray, INTERXFERMSGSET$10);
        }
    }
    
    /**
     * Sets ith "INTERXFERMSGSET" element
     */
    public void setINTERXFERMSGSETArray(int i, net.ofx.types.x2003.x04.InterTransferMessageSet interxfermsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InterTransferMessageSet)get_store().find_element_user(INTERXFERMSGSET$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(interxfermsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INTERXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.InterTransferMessageSet insertNewINTERXFERMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InterTransferMessageSet)get_store().insert_element_user(INTERXFERMSGSET$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INTERXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.InterTransferMessageSet addNewINTERXFERMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InterTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.InterTransferMessageSet)get_store().add_element_user(INTERXFERMSGSET$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "INTERXFERMSGSET" element
     */
    public void removeINTERXFERMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTERXFERMSGSET$10, i);
        }
    }
    
    /**
     * Gets array of all "WIREXFERMSGSET" elements
     */
    public net.ofx.types.x2003.x04.WireTransferMessageSet[] getWIREXFERMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(WIREXFERMSGSET$12, targetList);
            net.ofx.types.x2003.x04.WireTransferMessageSet[] result = new net.ofx.types.x2003.x04.WireTransferMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "WIREXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.WireTransferMessageSet getWIREXFERMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.WireTransferMessageSet)get_store().find_element_user(WIREXFERMSGSET$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "WIREXFERMSGSET" element
     */
    public int sizeOfWIREXFERMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WIREXFERMSGSET$12);
        }
    }
    
    /**
     * Sets array of all "WIREXFERMSGSET" element
     */
    public void setWIREXFERMSGSETArray(net.ofx.types.x2003.x04.WireTransferMessageSet[] wirexfermsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(wirexfermsgsetArray, WIREXFERMSGSET$12);
        }
    }
    
    /**
     * Sets ith "WIREXFERMSGSET" element
     */
    public void setWIREXFERMSGSETArray(int i, net.ofx.types.x2003.x04.WireTransferMessageSet wirexfermsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.WireTransferMessageSet)get_store().find_element_user(WIREXFERMSGSET$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(wirexfermsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "WIREXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.WireTransferMessageSet insertNewWIREXFERMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.WireTransferMessageSet)get_store().insert_element_user(WIREXFERMSGSET$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "WIREXFERMSGSET" element
     */
    public net.ofx.types.x2003.x04.WireTransferMessageSet addNewWIREXFERMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.WireTransferMessageSet target = null;
            target = (net.ofx.types.x2003.x04.WireTransferMessageSet)get_store().add_element_user(WIREXFERMSGSET$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "WIREXFERMSGSET" element
     */
    public void removeWIREXFERMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WIREXFERMSGSET$12, i);
        }
    }
    
    /**
     * Gets array of all "BILLPAYMSGSET" elements
     */
    public net.ofx.types.x2003.x04.BillPayMessageSet[] getBILLPAYMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BILLPAYMSGSET$14, targetList);
            net.ofx.types.x2003.x04.BillPayMessageSet[] result = new net.ofx.types.x2003.x04.BillPayMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BILLPAYMSGSET" element
     */
    public net.ofx.types.x2003.x04.BillPayMessageSet getBILLPAYMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BillPayMessageSet)get_store().find_element_user(BILLPAYMSGSET$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BILLPAYMSGSET" element
     */
    public int sizeOfBILLPAYMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BILLPAYMSGSET$14);
        }
    }
    
    /**
     * Sets array of all "BILLPAYMSGSET" element
     */
    public void setBILLPAYMSGSETArray(net.ofx.types.x2003.x04.BillPayMessageSet[] billpaymsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(billpaymsgsetArray, BILLPAYMSGSET$14);
        }
    }
    
    /**
     * Sets ith "BILLPAYMSGSET" element
     */
    public void setBILLPAYMSGSETArray(int i, net.ofx.types.x2003.x04.BillPayMessageSet billpaymsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BillPayMessageSet)get_store().find_element_user(BILLPAYMSGSET$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(billpaymsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BILLPAYMSGSET" element
     */
    public net.ofx.types.x2003.x04.BillPayMessageSet insertNewBILLPAYMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BillPayMessageSet)get_store().insert_element_user(BILLPAYMSGSET$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BILLPAYMSGSET" element
     */
    public net.ofx.types.x2003.x04.BillPayMessageSet addNewBILLPAYMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BillPayMessageSet target = null;
            target = (net.ofx.types.x2003.x04.BillPayMessageSet)get_store().add_element_user(BILLPAYMSGSET$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "BILLPAYMSGSET" element
     */
    public void removeBILLPAYMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BILLPAYMSGSET$14, i);
        }
    }
    
    /**
     * Gets array of all "EMAILMSGSET" elements
     */
    public net.ofx.types.x2003.x04.EmailMessageSet[] getEMAILMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(EMAILMSGSET$16, targetList);
            net.ofx.types.x2003.x04.EmailMessageSet[] result = new net.ofx.types.x2003.x04.EmailMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "EMAILMSGSET" element
     */
    public net.ofx.types.x2003.x04.EmailMessageSet getEMAILMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailMessageSet target = null;
            target = (net.ofx.types.x2003.x04.EmailMessageSet)get_store().find_element_user(EMAILMSGSET$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "EMAILMSGSET" element
     */
    public int sizeOfEMAILMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EMAILMSGSET$16);
        }
    }
    
    /**
     * Sets array of all "EMAILMSGSET" element
     */
    public void setEMAILMSGSETArray(net.ofx.types.x2003.x04.EmailMessageSet[] emailmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(emailmsgsetArray, EMAILMSGSET$16);
        }
    }
    
    /**
     * Sets ith "EMAILMSGSET" element
     */
    public void setEMAILMSGSETArray(int i, net.ofx.types.x2003.x04.EmailMessageSet emailmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailMessageSet target = null;
            target = (net.ofx.types.x2003.x04.EmailMessageSet)get_store().find_element_user(EMAILMSGSET$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(emailmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "EMAILMSGSET" element
     */
    public net.ofx.types.x2003.x04.EmailMessageSet insertNewEMAILMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailMessageSet target = null;
            target = (net.ofx.types.x2003.x04.EmailMessageSet)get_store().insert_element_user(EMAILMSGSET$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "EMAILMSGSET" element
     */
    public net.ofx.types.x2003.x04.EmailMessageSet addNewEMAILMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.EmailMessageSet target = null;
            target = (net.ofx.types.x2003.x04.EmailMessageSet)get_store().add_element_user(EMAILMSGSET$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "EMAILMSGSET" element
     */
    public void removeEMAILMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EMAILMSGSET$16, i);
        }
    }
    
    /**
     * Gets array of all "SECLISTMSGSET" elements
     */
    public net.ofx.types.x2003.x04.SecurityListMessageSet[] getSECLISTMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SECLISTMSGSET$18, targetList);
            net.ofx.types.x2003.x04.SecurityListMessageSet[] result = new net.ofx.types.x2003.x04.SecurityListMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SECLISTMSGSET" element
     */
    public net.ofx.types.x2003.x04.SecurityListMessageSet getSECLISTMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SecurityListMessageSet)get_store().find_element_user(SECLISTMSGSET$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SECLISTMSGSET" element
     */
    public int sizeOfSECLISTMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SECLISTMSGSET$18);
        }
    }
    
    /**
     * Sets array of all "SECLISTMSGSET" element
     */
    public void setSECLISTMSGSETArray(net.ofx.types.x2003.x04.SecurityListMessageSet[] seclistmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(seclistmsgsetArray, SECLISTMSGSET$18);
        }
    }
    
    /**
     * Sets ith "SECLISTMSGSET" element
     */
    public void setSECLISTMSGSETArray(int i, net.ofx.types.x2003.x04.SecurityListMessageSet seclistmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SecurityListMessageSet)get_store().find_element_user(SECLISTMSGSET$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(seclistmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SECLISTMSGSET" element
     */
    public net.ofx.types.x2003.x04.SecurityListMessageSet insertNewSECLISTMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SecurityListMessageSet)get_store().insert_element_user(SECLISTMSGSET$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SECLISTMSGSET" element
     */
    public net.ofx.types.x2003.x04.SecurityListMessageSet addNewSECLISTMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SecurityListMessageSet target = null;
            target = (net.ofx.types.x2003.x04.SecurityListMessageSet)get_store().add_element_user(SECLISTMSGSET$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "SECLISTMSGSET" element
     */
    public void removeSECLISTMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SECLISTMSGSET$18, i);
        }
    }
    
    /**
     * Gets array of all "PRESDIRMSGSET" elements
     */
    public net.ofx.types.x2003.x04.PresentmentDirMessageSet[] getPRESDIRMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PRESDIRMSGSET$20, targetList);
            net.ofx.types.x2003.x04.PresentmentDirMessageSet[] result = new net.ofx.types.x2003.x04.PresentmentDirMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PRESDIRMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirMessageSet getPRESDIRMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirMessageSet)get_store().find_element_user(PRESDIRMSGSET$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PRESDIRMSGSET" element
     */
    public int sizeOfPRESDIRMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDIRMSGSET$20);
        }
    }
    
    /**
     * Sets array of all "PRESDIRMSGSET" element
     */
    public void setPRESDIRMSGSETArray(net.ofx.types.x2003.x04.PresentmentDirMessageSet[] presdirmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(presdirmsgsetArray, PRESDIRMSGSET$20);
        }
    }
    
    /**
     * Sets ith "PRESDIRMSGSET" element
     */
    public void setPRESDIRMSGSETArray(int i, net.ofx.types.x2003.x04.PresentmentDirMessageSet presdirmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirMessageSet)get_store().find_element_user(PRESDIRMSGSET$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(presdirmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PRESDIRMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirMessageSet insertNewPRESDIRMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirMessageSet)get_store().insert_element_user(PRESDIRMSGSET$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PRESDIRMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDirMessageSet addNewPRESDIRMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDirMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDirMessageSet)get_store().add_element_user(PRESDIRMSGSET$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "PRESDIRMSGSET" element
     */
    public void removePRESDIRMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDIRMSGSET$20, i);
        }
    }
    
    /**
     * Gets array of all "PRESDLVMSGSET" elements
     */
    public net.ofx.types.x2003.x04.PresentmentDlvMessageSet[] getPRESDLVMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PRESDLVMSGSET$22, targetList);
            net.ofx.types.x2003.x04.PresentmentDlvMessageSet[] result = new net.ofx.types.x2003.x04.PresentmentDlvMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PRESDLVMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDlvMessageSet getPRESDLVMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDlvMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDlvMessageSet)get_store().find_element_user(PRESDLVMSGSET$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PRESDLVMSGSET" element
     */
    public int sizeOfPRESDLVMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PRESDLVMSGSET$22);
        }
    }
    
    /**
     * Sets array of all "PRESDLVMSGSET" element
     */
    public void setPRESDLVMSGSETArray(net.ofx.types.x2003.x04.PresentmentDlvMessageSet[] presdlvmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(presdlvmsgsetArray, PRESDLVMSGSET$22);
        }
    }
    
    /**
     * Sets ith "PRESDLVMSGSET" element
     */
    public void setPRESDLVMSGSETArray(int i, net.ofx.types.x2003.x04.PresentmentDlvMessageSet presdlvmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDlvMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDlvMessageSet)get_store().find_element_user(PRESDLVMSGSET$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(presdlvmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PRESDLVMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDlvMessageSet insertNewPRESDLVMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDlvMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDlvMessageSet)get_store().insert_element_user(PRESDLVMSGSET$22, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PRESDLVMSGSET" element
     */
    public net.ofx.types.x2003.x04.PresentmentDlvMessageSet addNewPRESDLVMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PresentmentDlvMessageSet target = null;
            target = (net.ofx.types.x2003.x04.PresentmentDlvMessageSet)get_store().add_element_user(PRESDLVMSGSET$22);
            return target;
        }
    }
    
    /**
     * Removes the ith "PRESDLVMSGSET" element
     */
    public void removePRESDLVMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PRESDLVMSGSET$22, i);
        }
    }
    
    /**
     * Gets array of all "TAX1099MSGSET" elements
     */
    public net.ofx.types.x2003.x04.Tax1099MessageSet[] getTAX1099MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TAX1099MSGSET$24, targetList);
            net.ofx.types.x2003.x04.Tax1099MessageSet[] result = new net.ofx.types.x2003.x04.Tax1099MessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "TAX1099MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1099MessageSet getTAX1099MSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1099MessageSet)get_store().find_element_user(TAX1099MSGSET$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "TAX1099MSGSET" element
     */
    public int sizeOfTAX1099MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1099MSGSET$24);
        }
    }
    
    /**
     * Sets array of all "TAX1099MSGSET" element
     */
    public void setTAX1099MSGSETArray(net.ofx.types.x2003.x04.Tax1099MessageSet[] tax1099MSGSETArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(tax1099MSGSETArray, TAX1099MSGSET$24);
        }
    }
    
    /**
     * Sets ith "TAX1099MSGSET" element
     */
    public void setTAX1099MSGSETArray(int i, net.ofx.types.x2003.x04.Tax1099MessageSet tax1099MSGSET)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1099MessageSet)get_store().find_element_user(TAX1099MSGSET$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(tax1099MSGSET);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "TAX1099MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1099MessageSet insertNewTAX1099MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1099MessageSet)get_store().insert_element_user(TAX1099MSGSET$24, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "TAX1099MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1099MessageSet addNewTAX1099MSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1099MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1099MessageSet)get_store().add_element_user(TAX1099MSGSET$24);
            return target;
        }
    }
    
    /**
     * Removes the ith "TAX1099MSGSET" element
     */
    public void removeTAX1099MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1099MSGSET$24, i);
        }
    }
    
    /**
     * Gets array of all "TAX1098MSGSET" elements
     */
    public net.ofx.types.x2003.x04.Tax1098MessageSet[] getTAX1098MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TAX1098MSGSET$26, targetList);
            net.ofx.types.x2003.x04.Tax1098MessageSet[] result = new net.ofx.types.x2003.x04.Tax1098MessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "TAX1098MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1098MessageSet getTAX1098MSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1098MessageSet)get_store().find_element_user(TAX1098MSGSET$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "TAX1098MSGSET" element
     */
    public int sizeOfTAX1098MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAX1098MSGSET$26);
        }
    }
    
    /**
     * Sets array of all "TAX1098MSGSET" element
     */
    public void setTAX1098MSGSETArray(net.ofx.types.x2003.x04.Tax1098MessageSet[] tax1098MSGSETArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(tax1098MSGSETArray, TAX1098MSGSET$26);
        }
    }
    
    /**
     * Sets ith "TAX1098MSGSET" element
     */
    public void setTAX1098MSGSETArray(int i, net.ofx.types.x2003.x04.Tax1098MessageSet tax1098MSGSET)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1098MessageSet)get_store().find_element_user(TAX1098MSGSET$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(tax1098MSGSET);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "TAX1098MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1098MessageSet insertNewTAX1098MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1098MessageSet)get_store().insert_element_user(TAX1098MSGSET$26, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "TAX1098MSGSET" element
     */
    public net.ofx.types.x2003.x04.Tax1098MessageSet addNewTAX1098MSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Tax1098MessageSet target = null;
            target = (net.ofx.types.x2003.x04.Tax1098MessageSet)get_store().add_element_user(TAX1098MSGSET$26);
            return target;
        }
    }
    
    /**
     * Removes the ith "TAX1098MSGSET" element
     */
    public void removeTAX1098MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAX1098MSGSET$26, i);
        }
    }
    
    /**
     * Gets array of all "TAXW2MSGSET" elements
     */
    public net.ofx.types.x2003.x04.TaxW2MessageSet[] getTAXW2MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TAXW2MSGSET$28, targetList);
            net.ofx.types.x2003.x04.TaxW2MessageSet[] result = new net.ofx.types.x2003.x04.TaxW2MessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "TAXW2MSGSET" element
     */
    public net.ofx.types.x2003.x04.TaxW2MessageSet getTAXW2MSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2MessageSet target = null;
            target = (net.ofx.types.x2003.x04.TaxW2MessageSet)get_store().find_element_user(TAXW2MSGSET$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "TAXW2MSGSET" element
     */
    public int sizeOfTAXW2MSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TAXW2MSGSET$28);
        }
    }
    
    /**
     * Sets array of all "TAXW2MSGSET" element
     */
    public void setTAXW2MSGSETArray(net.ofx.types.x2003.x04.TaxW2MessageSet[] taxw2MSGSETArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(taxw2MSGSETArray, TAXW2MSGSET$28);
        }
    }
    
    /**
     * Sets ith "TAXW2MSGSET" element
     */
    public void setTAXW2MSGSETArray(int i, net.ofx.types.x2003.x04.TaxW2MessageSet taxw2MSGSET)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2MessageSet target = null;
            target = (net.ofx.types.x2003.x04.TaxW2MessageSet)get_store().find_element_user(TAXW2MSGSET$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(taxw2MSGSET);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "TAXW2MSGSET" element
     */
    public net.ofx.types.x2003.x04.TaxW2MessageSet insertNewTAXW2MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2MessageSet target = null;
            target = (net.ofx.types.x2003.x04.TaxW2MessageSet)get_store().insert_element_user(TAXW2MSGSET$28, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "TAXW2MSGSET" element
     */
    public net.ofx.types.x2003.x04.TaxW2MessageSet addNewTAXW2MSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.TaxW2MessageSet target = null;
            target = (net.ofx.types.x2003.x04.TaxW2MessageSet)get_store().add_element_user(TAXW2MSGSET$28);
            return target;
        }
    }
    
    /**
     * Removes the ith "TAXW2MSGSET" element
     */
    public void removeTAXW2MSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TAXW2MSGSET$28, i);
        }
    }
    
    /**
     * Gets array of all "PROFMSGSET" elements
     */
    public net.ofx.types.x2003.x04.ProfileMessageSet[] getPROFMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PROFMSGSET$30, targetList);
            net.ofx.types.x2003.x04.ProfileMessageSet[] result = new net.ofx.types.x2003.x04.ProfileMessageSet[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PROFMSGSET" element
     */
    public net.ofx.types.x2003.x04.ProfileMessageSet getPROFMSGSETArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileMessageSet target = null;
            target = (net.ofx.types.x2003.x04.ProfileMessageSet)get_store().find_element_user(PROFMSGSET$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PROFMSGSET" element
     */
    public int sizeOfPROFMSGSETArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PROFMSGSET$30);
        }
    }
    
    /**
     * Sets array of all "PROFMSGSET" element
     */
    public void setPROFMSGSETArray(net.ofx.types.x2003.x04.ProfileMessageSet[] profmsgsetArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(profmsgsetArray, PROFMSGSET$30);
        }
    }
    
    /**
     * Sets ith "PROFMSGSET" element
     */
    public void setPROFMSGSETArray(int i, net.ofx.types.x2003.x04.ProfileMessageSet profmsgset)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileMessageSet target = null;
            target = (net.ofx.types.x2003.x04.ProfileMessageSet)get_store().find_element_user(PROFMSGSET$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(profmsgset);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PROFMSGSET" element
     */
    public net.ofx.types.x2003.x04.ProfileMessageSet insertNewPROFMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileMessageSet target = null;
            target = (net.ofx.types.x2003.x04.ProfileMessageSet)get_store().insert_element_user(PROFMSGSET$30, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PROFMSGSET" element
     */
    public net.ofx.types.x2003.x04.ProfileMessageSet addNewPROFMSGSET()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ProfileMessageSet target = null;
            target = (net.ofx.types.x2003.x04.ProfileMessageSet)get_store().add_element_user(PROFMSGSET$30);
            return target;
        }
    }
    
    /**
     * Removes the ith "PROFMSGSET" element
     */
    public void removePROFMSGSET(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PROFMSGSET$30, i);
        }
    }
}
